{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<center>\n",
    "<img src=\"../../img/ods_stickers.jpg\">\n",
    "## Открытый курс по машинному обучению. Сессия № 2\n",
    "\n",
    "### <center> Автор материала: Князятов Станислав (@StanislavLeet)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <center> Индивидуальный проект по анализу данных </center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.1 Описание решаемой задачи"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Предсказание банкротства было предметом интересов уже более ста лет, и оно по-прежнему занимает высокое место среди самых горячих тем в экономике. Оно имеет большое значение для принятия экономических решений, т.к. бизнес-состояние небольшой или крупной фирмы касается местного сообщества, участников отрасли и инвесторов, а также влияет на политику и глобальную экономику.\n",
    "\n",
    "**Целью прогноза ** банкротства является оценка финансового состояния компании и ее будущих перспектив в контексте долговременной работы на рынке используя экспертные знания о феномене и исторические данные процветающих и безуспешных компаний. В данной работе предприятия будут описываться количественно с помощью многочисленных бизнес индекаторов.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.2 Сбор данных"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В данной работе использовались данные о финансовом состоянии польских компаний. Процесс отбора данных состоит из выбора сектора, базы данных, периода исследования и количества финансовых показателей, которые будут проанализированы. В Польше, начиная с 2004г,  максимальное количество банкротств было зафиксировано в производственном секторе (the manufacturing sector), поэтому для данного исследования этот сектор представляет наибольший интерес. Данные брались из базы данных информационной службы развивающихся рынков (EMIS). Для компаний указаны финансовые показатели за целевой год и указана метка о банкротстве в течении 5 лет. Финансовые показатели были выбраны на основе анализа популярных и эффективных показателей в смежных работах."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.3 Описание целевого и прочих признаков"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Все используемые в данной задаче признаки, кроме целевого, числовые.\n",
    "\n",
    "\n",
    "**Признаки**: \n",
    "\n",
    "- **Attr1** : чистая прибыль / совокупные активы\n",
    "\n",
    "\n",
    "- **Attr2** : Все (total) обязательства / совокупные активы\n",
    "\n",
    "\n",
    "- **Attr3** : оборотный капитал / совокупные активы\n",
    "\n",
    "\n",
    "- **Attr4** : текущие активы / краткосрочные обязательства\n",
    "\n",
    "\n",
    "- **Attr5** : [(денежные средства + краткосрочные ценные бумаги + дебиторская задолженность -\n",
    "  краткосрочные обязательства) / (операционные расходы - амортизация)] * 365,\n",
    "\n",
    "\n",
    "- **Attr6** : Нераспределенная прибыль / совокупные активы\n",
    "\n",
    "\n",
    "- **Attr7** : прибыль до начисления процентов / совокупные активы\n",
    "\n",
    "\n",
    "- **Attr8** : балансовая стоимость собственного капитала / Все (total) обязательства\n",
    "\n",
    "\n",
    "- **Attr9** : продажи / совокупные активы\n",
    "\n",
    "\n",
    "- **Attr10** : капитал / совокупные активы\n",
    "\n",
    "\n",
    "- **Attr11** : (валовая прибыль + внереализационные статьи + финансовые расходы) / совокупные активы\n",
    "\n",
    "\n",
    "- **Attr12** : валовая прибыль / краткосрочные обязательства\n",
    "\n",
    "\n",
    "- **Attr13** : (валовая прибыль + амортизация) / продажи\n",
    "\n",
    "\n",
    "- **Attr14** : (валовая прибыль + interest) / совокупные активы\n",
    "\n",
    "\n",
    "- **Attr15** : (Все (total) обязательства * 365) / (валовая прибыль + амортизация)\n",
    "\n",
    "\n",
    "- **Attr16** : (валовая прибыль + амортизация) / Все (total) обязательства\n",
    "\n",
    "\n",
    "- **Attr17** : совокупные активы / Все (total) обязательства\n",
    "\n",
    "\n",
    "- **Attr18** : валовая прибыль / совокупные активы\n",
    "\n",
    "\n",
    "- **Attr19** : валовая прибыль / продажи\n",
    "\n",
    "\n",
    "- **Attr20** : (инвентарь * 365) / продажи\n",
    "\n",
    "\n",
    "- **Attr21** : продажи (n) / продажи (n-1)\n",
    "\n",
    "\n",
    "- **Attr22** : прибыль от операционной деятельности / совокупные активы\n",
    "\n",
    "\n",
    "- **Attr23** : чистая прибыль / продажи\n",
    "\n",
    "\n",
    "- **Attr24** : валовая прибыль (за 3 года) / совокупные активы\n",
    "\n",
    "\n",
    "- **Attr25** : (собственный капитал - акционерный капитал) / совокупные активы\n",
    "\n",
    "\n",
    "- **Attr26** : (чистая прибыль + амортизация) / Все (total) обязательства\n",
    "\n",
    "\n",
    "- **Attr27** : прибыль от операционной деятельности / финансовые расходы\n",
    "\n",
    "\n",
    "- **Attr28** : оборотный капитал / основные средства\n",
    "\n",
    "\n",
    "- **Attr29** : натуральный логарифм от величины общих активов\n",
    "\n",
    "\n",
    "- **Attr30** : (общие обязательства - наличные) / продажи\n",
    "\n",
    "\n",
    "- **Attr31** : (валовая прибыль + interest) / продажи\n",
    "\n",
    "\n",
    "- **Attr32** : (текущие обязательства * 365) / себестоимость реализованной продукции\n",
    "\n",
    "\n",
    "- **Attr33** : операционные расходы / краткосрочные обязательства\n",
    "\n",
    "\n",
    "- **Attr34** : операционные расходы / общие обязательства\n",
    "\n",
    "\n",
    "- **Attr35** : прибыль от продаж / общие активы\n",
    "\n",
    "\n",
    "- **Attr36** : общие продажи / общие активы\n",
    "\n",
    "\n",
    "- **Attr37** : (оборотные активы - запасы) / долгосрочные обязательства\n",
    "\n",
    "\n",
    "- **Attr38** : постоянный капитал / общие активы\n",
    "\n",
    "\n",
    "- **Attr39** : прибыль от продаж / продажи\n",
    "\n",
    "\n",
    "- **Attr40** : (текущие активы - запасы - дебиторская задолженность) / краткосрочные обязательства\n",
    "\n",
    "\n",
    "- **Attr41** : общие обязательства / ((прибыль от операционной деятельности + амортизация) * (12/365))\n",
    "\n",
    "\n",
    "- **Attr42** : прибыль от операционной деятельности / продаж\n",
    "\n",
    "\n",
    "- **Attr43** : оборотная дебиторская задолженность + оборот запасов в днях\n",
    "\n",
    "\n",
    "- **Attr44** : (дебиторская задолженность * 365) / продажи\n",
    "\n",
    "\n",
    "- **Attr45** : чистая прибыль / запасы\n",
    "\n",
    "\n",
    "- **Attr46** : (оборотные активы - запасы) / краткосрочные обязательства\n",
    "\n",
    "\n",
    "- **Attr47** : (запасы * 365) / стоимость проданной продукции\n",
    "\n",
    "\n",
    "- **Attr48** : EBITDA (прибыль от операционной деятельности - амортизация) / общие активы\n",
    "\n",
    "\n",
    "- **Attr49** : EBITDA (прибыль от операционной деятельности - амортизация) / продажи\n",
    "\n",
    "\n",
    "- **Attr50** : текущие активы / общие обязательства\n",
    "\n",
    "\n",
    "- **Attr51** : краткосрочные обязательства / общие активы\n",
    "\n",
    "\n",
    "- **Attr52** : (краткосрочные обязательства * 365) / стоимость проданной продукции\n",
    "\n",
    "\n",
    "- **Attr53** : собственный капитал / основные средства\n",
    "\n",
    "\n",
    "- **Attr54** : постоянный капитал / основные средства\n",
    "\n",
    "\n",
    "- **Attr55** : оборотный капитал\n",
    "\n",
    "\n",
    "- **Attr56** : (продажи - стоимость проданной продукции) / продажи\n",
    "\n",
    "\n",
    "- **Attr57** : (текущие активы - запасы - краткосрочные обязательства) / (выручка - валовая прибыль - амортизация)\n",
    "\n",
    "\n",
    "- **Attr58** : общие затраты / общий объем продаж\n",
    "\n",
    "\n",
    "- **Attr59** : долгосрочные обязательства / собственный капитал\n",
    "\n",
    "\n",
    "- **Attr60** : продажа / инвентарь\n",
    "\n",
    "\n",
    "- **Attr61** : продажи / дебиторская задолженность\n",
    "\n",
    "\n",
    "- **Attr62** : (краткосрочные обязательства * 365) / продажи\n",
    "\n",
    "\n",
    "- **Attr63** : продажи / краткосрочные обязательства\n",
    "\n",
    "\n",
    "- **Attr64** : продажи / основные средства\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "** Целевая переменная ** : \n",
    "\n",
    "- **target** :  бинарная метка представляющая банкротство компании: 0 = Нет, 1 = Да."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. Загрузка данных  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Загрузим исходные данные и посмотрим на них."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.model_selection import GridSearchCV\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.decomposition import PCA\n",
    "from sklearn.tree import DecisionTreeClassifier\n",
    "from sklearn.model_selection import KFold\n",
    "from sklearn.metrics import roc_auc_score\n",
    "import seaborn as sns\n",
    "import warnings\n",
    "warnings.filterwarnings('ignore')\n",
    "%pylab inline\n",
    "\n",
    "\n",
    "def findpass(s):\n",
    "    if s in '?':\n",
    "        return '?';\n",
    "    else:\n",
    "        return float(s);\n",
    "    \n",
    "def arfftoDataframe(name, num_features):\n",
    "    with open(name, 'r') as inf:\n",
    "        X = [];\n",
    "        for i in range(num_features+5):\n",
    "            next(inf);\n",
    "            \n",
    "            \n",
    "        for line in inf:\n",
    "            line = line.strip();\n",
    "            X.append(line.split(','))\n",
    "            \n",
    "            \n",
    "        D = pd.DataFrame()\n",
    "        X = np.array(X)\n",
    "        for i in range(num_features):\n",
    "            D['Attr' + str(i+1)] = np.array([findpass(i) for i in X[:,i]])\n",
    "        D['target'] = np.array([int(i) for i in X[:,-1]])\n",
    "        return D\n",
    "        \n",
    "data = arfftoDataframe('1year.arff', 64)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data.info()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3. Обработка пропусков"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Видно, что только у 16 признаков полностью заполнены все значения, найдем долю пропусков для каждого из столбцов. В этом датасете, пропуски обозначенны знаком вопроса."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d = {};\n",
    "for i in data.columns:\n",
    "    if '?' in data[i].value_counts():\n",
    "        d[i] = data[i].value_counts()['?']*100/len(data)\n",
    "        \n",
    "for i in d.keys():\n",
    "    if d[i] > 1.0:\n",
    "        print(i, d[i])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Для признаков Attr21 и Attr37 слишком большое количество пропусков, из-за этого их не получится восстановить с помощью интерполяции, поэтому удалим их."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = data.drop(['Attr21', 'Attr37'], axis = 1)\n",
    "del d['Attr21']\n",
    "del d['Attr37']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Далее проведем работу со строками, подсчитаем количество строк у которых в признаках больше одного неизвестного значения и оставим строки где не более 3 пропусков в строке, это эквивалентное условию о том, что о компании нам известно не менее 95% информации."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "strings = {};\n",
    "for i in d.keys():\n",
    "    for j in range(len(data[i])):\n",
    "        if data[i][j] in '?':\n",
    "            if j not in strings.keys():\n",
    "                strings[j] = 1\n",
    "            else:\n",
    "                strings[j] += 1;\n",
    "\n",
    "del_s = []\n",
    "for i in strings.keys():\n",
    "    if strings[i] > 3:\n",
    "        del_s.append(i)\n",
    "        \n",
    "data = data.drop(del_s, axis = 0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Выделим в отдельный массив все оставшиеся строки с пропусками и оставшиеся элементы DataFrame приведем к формату с плавающей точкой."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in del_s:\n",
    "    del strings[i]\n",
    "    \n",
    "sk = [];\n",
    "for i in strings.keys():\n",
    "    sk += [i]    \n",
    "      \n",
    "X_strings = data.loc[np.array(sk)];\n",
    "data = data.drop(strings.keys(), axis = 0)    \n",
    "\n",
    "for i in d.keys():\n",
    "    data[i] = data[i].astype(float) \n",
    "    \n",
    "    \n",
    "\n",
    "stings_without_str = [];\n",
    "\n",
    "for i in d.keys():\n",
    "    k = 0;\n",
    "    for j in X_strings[i]:\n",
    "        if j in '?':\n",
    "            k += 1;\n",
    "    if k == 0:\n",
    "        stings_without_str += [i];\n",
    "        \n",
    "for i in stings_without_str:\n",
    "    del d[i];    \n",
    "    \n",
    "    \n",
    "for i in d.keys():\n",
    "    d[i] = X_strings[i].value_counts()['?']*100/len(data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Посмотрим на статистику отсуствующих признаков."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data.describe()[[i for i in d.keys()]].T"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Видно, что у многих признаков std, минимальное и максимальное значения очень велики, поэтому нельзя заменить средним или медианным значением. Тогда для заполнения пропусков решим дополнительную подзадачу, построим регрессию на основе дерева. Данный выбор обуславливается тем, что дерево быстро обучить и оно склонно к переобучению, что в задаче заполнения пропусков является положительной чертой.\n",
    "\n",
    "\n",
    "Построим словарь индексов с номерами строк с пропусками для каждого из столбцов и на его основе построим матрицу А, элементами которой будут количество одинаковых строк у разных столбцов. На её основе выберем порядок заполнения пропущенных столбцов и количество столбцов для обучения. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dict_of_sets = {};\n",
    "for i in d.keys():\n",
    "    nums = []\n",
    "    for j in X_strings.index:\n",
    "        if X_strings[i][j] == '?':\n",
    "            nums += [j];\n",
    "    dict_of_sets[i] = set(nums);\n",
    "A = [[len(dict_of_sets[i].intersection(dict_of_sets[j]))   for j in dict_of_sets.keys()] for i in dict_of_sets.keys()]\n",
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dict_of_sets.keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.tree import DecisionTreeRegressor\n",
    "\n",
    "    \n",
    "def predict_and_notconcat(clf, choose_columns, X, data, d, dict_of_sets):\n",
    "    for col in choose_columns:\n",
    "        clf.fit(data.drop(col, axis=1), data[col[0]]);\n",
    "        pred_data = X.drop(col, axis=1).loc[dict_of_sets[col[0]]]\n",
    "        for i in pred_data.columns:\n",
    "            pred_data[i] = pred_data[i].astype(float)\n",
    "        pred_data[col[0]] = clf.predict(pred_data)\n",
    "        for i in dict_of_sets[col[0]]:\n",
    "            X[col[0]][i] = pred_data[col[0]][i]\n",
    "        del d[col[0]] \n",
    "    return X\n",
    "\n",
    "clf = DecisionTreeRegressor(random_state = 0, min_samples_leaf = 2)\n",
    "\n",
    "\n",
    "for col in ['Attr11', 'Attr46', 'Attr61']:\n",
    "    clf.fit(data.drop([col], axis=1), data[col]);\n",
    "    pred_data = X_strings.drop([col], axis=1).loc[dict_of_sets[col]]\n",
    "    X_strings = X_strings.drop(dict_of_sets[col], axis = 0) \n",
    "    for i in pred_data.columns:\n",
    "        pred_data[i] = pred_data[i].astype(float)\n",
    "    pred_data[col] = clf.predict(pred_data)\n",
    "    data = pd.concat([data, pred_data])\n",
    "    del d[col]\n",
    "X_strings = predict_and_notconcat(clf, [['Attr5', 'Attr32']], X_strings, data, d, dict_of_sets)\n",
    "X_strings = predict_and_notconcat(clf, [['Attr47', 'Attr32', 'Attr52'], ['Attr52', 'Attr32', 'Attr47']], X_strings, data, d, dict_of_sets)\n",
    "\n",
    "for col in ['Attr32']:\n",
    "    clf.fit(data.drop([col], axis=1), data[col]);\n",
    "    pred_data = X_strings.drop([col], axis=1).loc[dict_of_sets[col]]\n",
    "    X_strings = X_strings.drop(dict_of_sets[col], axis = 0) \n",
    "    for i in pred_data.columns:\n",
    "        pred_data[i] = pred_data[i].astype(float)\n",
    "    pred_data[col] = clf.predict(pred_data)\n",
    "    data = pd.concat([data, pred_data])\n",
    "    del d[col]\n",
    "\n",
    "\n",
    "\n",
    "X_strings = predict_and_notconcat(clf, [['Attr41', 'Attr27', 'Attr24', 'Attr45', 'Attr60']], X_strings, data, d, dict_of_sets)\n",
    "X_strings = predict_and_notconcat(clf, [['Attr24', 'Attr27', 'Attr45', 'Attr60']], X_strings, data, d, dict_of_sets)\n",
    "X_strings = predict_and_notconcat(clf, [['Attr45', 'Attr27', 'Attr60'], ['Attr60', 'Attr45', 'Attr27']], X_strings, data, d, dict_of_sets)\n",
    "\n",
    "for col in ['Attr27']:\n",
    "    clf.fit(data.drop([col], axis=1), data[col]);\n",
    "    pred_data = X_strings.drop([col], axis=1).loc[dict_of_sets[col]]\n",
    "    X_strings = X_strings.drop(dict_of_sets[col], axis = 0) \n",
    "    for i in pred_data.columns:\n",
    "        pred_data[i] = pred_data[i].astype(float)\n",
    "    pred_data[col] = clf.predict(pred_data)\n",
    "    data = pd.concat([data, pred_data])\n",
    "    del d[col]\n",
    "    \n",
    "    \n",
    "for i in X_strings.columns:\n",
    "    X_strings[i] = X_strings[i].astype(float)\n",
    "    \n",
    "data = pd.concat([data, X_strings])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.1 Выбор метрики в задаче"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Рассмотренные далее классификаторы возвращают вероятность принадлежности к целевому классу, в зависимости от смысла бизнес задачи (инвестиционная деятельность, хеджирование, государственная поддержка) пороги будут выбираться согласно её логики. Не зная какой-то конкретный порог заранее, следует оценивать семейство алгоритмов, параметром которого является порог. Для этого подойдет интегральная метрика roc_auc, которая и будет использоваться в дальнейшем."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.2 Оценка качества работы"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В процессе исследования у нас возникнет вопрос о сравнении качества моделей и доказательства целесообразности проведенного анализа. Для решения первой задачи мы построим алгоритм случайного леса на исходных сырых данных. Выбор данного алгоритма обуславливается тем, что он наименее прихотлив к предобработке данных. Для решении второй задачи мы создадим отложенную выборку и результат полученного алгоритма сопоставим с baseline. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.3 Отложенная выборка"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Поместим в отложенную выборку 10% необработанных исходных данных, так что бы пропорции классов сохранялись."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data['target'].hist(orientation='horizontal', figsize=(10,5))\n",
    "\n",
    "\n",
    "print('Распределение классов:')\n",
    "100*data['target'].value_counts() / data.shape[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Округлим до целых, получим, что 96% данных принадлежит к нулевому классу и 4% к целевому. В отложенной выборке будет 695 элементов, 28 из которых будут принадлежать к целевому классу, а остальные к нулевому."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.random.seed(0)\n",
    "A = np.hstack((random.choice(data[data['target'] == 0].index, 667, replace = False),\n",
    "           random.choice(data[data['target'] == 1].index, 28, replace = False)))\n",
    "\n",
    "Deferred_selection = data.loc[A]\n",
    "data.drop(A, axis = 0, inplace = True)  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.4 Baseline "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Из гистограммы в прошлом пункте видно, что классы сильно не сбалансированны, поэтому здесь и далее в алгоритмах будет использоваться параметр class_weight = 'balanced'. Найдем, используя кросс-валидацию, лучшие параметры алгоритма случайного леса на исходных сырых данных."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "forrest_param = {'n_estimators' : range(50, 120, 10), 'max_depth' : range(1,5), 'min_samples_leaf': range(1,10)}\n",
    "\n",
    "clf = RandomForestClassifier(n_estimators = 50, max_depth = 10, min_samples_leaf = 5, class_weight = 'balanced', random_state = 0)\n",
    "tree_grid = GridSearchCV(clf, forrest_param, cv=30, n_jobs=-1, scoring = 'roc_auc')\n",
    "tree_grid.fit(data.drop(['target'], axis=1), data['target'])\n",
    "print(tree_grid.best_params_)\n",
    "print(tree_grid.best_score_)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Построим прогноз для отложенной выборки и получим baseline."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "clf = RandomForestClassifier(n_estimators = 80, max_depth = 4, min_samples_leaf = 6, class_weight = 'balanced', random_state = 0)\n",
    "clf.fit(data.drop(['target'], axis=1), data['target'])\n",
    "pred = clf.predict_proba(Deferred_selection.drop(['target'], axis=1))\n",
    "roc_auc_score(Deferred_selection['target'], pred[:,1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "### 5 Анализ зависимостей в данных"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Построим матрицу ковариации для анализа линейных зависимостей между признаками."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sns.set(font_scale=2.5)\n",
    "plt.figure(figsize=(60,30))\n",
    "corr_matrix=data.corr()\n",
    "sns.heatmap(corr_matrix,annot=True,fmt = \".2f\",cbar = True,cmap='PuOr',annot_kws={\"size\":17})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Видно, что довольно много линейно зависимых признаков. Попробуем сжать признаковое пространство, оставив лишь несколько независимых. Т.к. признаки имеют разный масштаб, перед их трансформацией отмасштабируем их, это никак не повлияет на матрицу корреляции. Не забудем и про отложенную выборку. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in data.drop(['target'], axis = 1).columns:\n",
    "    scaler = StandardScaler()\n",
    "    scaler.fit(data[i])\n",
    "    data[i] = scaler.transform(data[i])   \n",
    "    Deferred_selection[i] = scaler.transform(Deferred_selection[i]);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "С помощью алгоритма PCA выясним какое количество новых компонент будут давать 90% дисперсии. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pca = PCA()\n",
    "pca.fit(data.drop(['target'], axis=1))\n",
    "X_reduced = pca.fit_transform(data.drop(['target'], axis=1))\n",
    "\n",
    "\n",
    "\n",
    "plt.figure(figsize=(10,7))\n",
    "plt.plot(np.cumsum(pca.explained_variance_ratio_), color='k', lw=2)\n",
    "plt.xlabel('Number of components')\n",
    "plt.ylabel('Total explained variance')\n",
    "plt.xlim(1, 62)\n",
    "plt.yticks(np.arange(0, 1.1, 0.1))\n",
    "plt.axvline(67, c='b')\n",
    "plt.axhline(0.9, c='r')\n",
    "plt.show();\n",
    "\n",
    "\n",
    "sum = 0.0;\n",
    "k = 1;\n",
    "for i in pca.explained_variance_ratio_:\n",
    "    sum += i;\n",
    "    if sum < 0.9:\n",
    "        k += 1;\n",
    "print(k)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Вычисления показывают, что 16 признаков достаточно для хорошего приближения исходных признаков."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pca = PCA(16)\n",
    "X_reduced = pca.fit_transform(data.drop(['target'], axis=1))\n",
    "Deferred_selection_reduced = pca.transform(Deferred_selection.drop(['target'], axis=1))\n",
    "\n",
    "\n",
    "del_columns = data.drop(['target'], axis=1).columns\n",
    "for i in del_columns:\n",
    "    del data[i]\n",
    "    del Deferred_selection[i]\n",
    "    \n",
    "    \n",
    "for i in range(16):\n",
    "    data['Attr'+str(i+1)] = X_reduced[:,i]\n",
    "    Deferred_selection['Attr'+str(i+1)] = Deferred_selection_reduced[:,i]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 6. Визуальный анализ данных"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Построим и посмотрим на распределения признаков."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in data.drop(['target'], axis = 1).columns:\n",
    "    fig, ax = plt.subplots(ncols=3, sharey=True, figsize=(17,4))\n",
    "    sns.distplot(data[data['target'] == 0][i], ax=ax[0])\n",
    "    sns.distplot(data[data['target'] == 1][i], ax=ax[0], color=\"orange\")\n",
    "    sns.distplot(data[data['target'] == 0][i], ax=ax[1])\n",
    "    sns.distplot(data[data['target'] == 1][i], ax=ax[2], color=\"orange\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Видно, что все признаки распределены на достаточно большом отрезке, причем большая часть элементов сосредоточена в центре распределения, а на концах лишь носители нулевого класса. Поэтому предположим, что экстремальные значения признаков характерны только для нулевого класса. На основе этого добавим простой классификатор, если точка не лежит внутри некоторой области в признаковом пространстве, то мы автоматически классифицируем её нулевым признаком. Данный подход опасен тем, что, зная лишь часть данных, можно переобучиться на них и построить слишком жесткие рамки, постараемся этого избежать\n",
    "\n",
    "Для аппроксимации границы области воспользуемся классифицирующем деревом. Далее анализ опущен ввиду своей громоздкости, но его этапы были следующими:\n",
    "\n",
    "1) Построение границ для каждого из признаков;\n",
    "\n",
    "2) Соотнесение границы с нашими данными.\n",
    "\n",
    "В процессе второго этапа, почти во всех случаях граница была увеличена не менее чем в 1.5 раза, для снижения вероятности переобучения\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Скорректированные отрезки для признаков имеют следующий вид:\n",
    "\n",
    "Attr1 -> [-5.37, 3.3]\n",
    "\n",
    "Attr2 -> [-19.85, 41.63]\n",
    "\n",
    "Attr3 -> [-16.36, 54.2]\n",
    "\n",
    "Attr4 -> [-6, 44.01] \n",
    "\n",
    "Attr5 -> [-7.56, 4.44]\n",
    "\n",
    "Attr6 -> [-3.09, 0.135]\n",
    "\n",
    "Attr7 -> [-3.15, 3.15]\n",
    "\n",
    "Attr8 -> [-11.895, 8]\n",
    "\n",
    "Attr9 -> [-10, 2]\n",
    "\n",
    "Attr10 -> [-5, 5]\n",
    "\n",
    "Attr11 -> [-5, 5]\n",
    "\n",
    "Attr12 -> [-5, 5]\n",
    "\n",
    "Attr13 -> [-5, 5]\n",
    "\n",
    "Attr14 -> [-5, 5]\n",
    "\n",
    "Attr15 -> [-2.09, 1.19]\n",
    "\n",
    "Attr16 -> [-5, 8]\n",
    "\n",
    "Уберем из рассмотрения все примеры, где хотя бы один из признаков лежит в экстремальных значениях. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Barrier = {'1' : [-5.37, 3.3], '2' : [-19.85, 41.63], '3' : [-16.36, 54.2],\n",
    "          '4' : [-6, 44.01], '5' : [-7.56, 4.44], '6' : [-3.09, 0.135],\n",
    "          '7' : [-3.15, 3.15], '8' : [-11.895, 8], '9' : [-10, 2],\n",
    "          '10' : [-5, 5], '11' : [-5, 5], '12' : [-5, 5],\n",
    "          '13' : [-5, 5], '14' : [-5, 5], '15' : [-2.09, 1.19],\n",
    "          '16' : [-5, 8]}\n",
    "\n",
    "def Check_Barrier(b, string):\n",
    "    for i in b.keys():\n",
    "        if string[int(i)] < b[i][0] or string[int(i)] > b[i][1]:\n",
    "            return False\n",
    "    return True\n",
    "\n",
    "\n",
    "X_new = [];\n",
    "XX = np.array(data)\n",
    "for i in XX:\n",
    "    if Check_Barrier(Barrier, i):\n",
    "        X_new += [i]\n",
    "        \n",
    "X_new = np.array(X_new)        \n",
    "help_d = {'target': X_new[:,0]}\n",
    "df = pd.DataFrame(data=help_d)\n",
    "for i in range(1, 17):\n",
    "    df['Attr'+str(i)] = np.array(X_new[:,i])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Проведем эту процедуру и для отложенной выборки, разделив её на 2 части. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "XX = np.array(Deferred_selection)\n",
    "X_new = [];\n",
    "X_old = [];\n",
    "for i in XX:\n",
    "    if Check_Barrier(Barrier, i):\n",
    "        X_new += [i];\n",
    "    else:\n",
    "        X_old += [i];\n",
    "\n",
    "X_new = np.array(X_new)\n",
    "X_old = np.array(X_old)\n",
    "\n",
    "help_d = {'target': X_new[:,0]}\n",
    "DSinB = pd.DataFrame(data=help_d)\n",
    "help_d = {'target': X_old[:,0]}\n",
    "DSnotinB = pd.DataFrame(data=help_d)\n",
    "\n",
    "for i in range(1, 17):\n",
    "    DSinB['Attr'+str(i)] = np.array(X_new[:,i])\n",
    "    DSnotinB['Attr'+str(i)] = np.array(X_old[:,i])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Отмасштабируем полученные признаки, отрисуем их и проверим их линейную независимость. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in df.drop(['target'], axis = 1).columns:\n",
    "    scaler = StandardScaler()\n",
    "    scaler.fit(df[i])\n",
    "    df[i] = scaler.transform(df[i])\n",
    "    DSinB[i] = scaler.transform(DSinB[i])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in df.drop(['target'], axis = 1).columns:\n",
    "    fig, ax = plt.subplots(ncols=3, sharey=True, figsize=(17,4))\n",
    "    sns.distplot(df[df['target'] == 0][i], ax=ax[0])\n",
    "    sns.distplot(df[df['target'] == 1][i], ax=ax[0], color=\"orange\")\n",
    "    sns.distplot(df[df['target'] == 0][i], ax=ax[1])\n",
    "    sns.distplot(df[df['target'] == 1][i], ax=ax[2], color=\"orange\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sns.set(font_scale=2.5)\n",
    "plt.figure(figsize=(60,30))\n",
    "corr_matrix=df.corr()\n",
    "sns.heatmap(corr_matrix,annot=True,fmt = \".2f\",cbar = True,cmap='PuOr',annot_kws={\"size\":17})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "К сожалению у нас снова появились скоррелированные признаки, но масштаб бедствий не так серьезен, как раньше. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 7. Создание полиноминальных признаков"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Перед тем, как перейти к созданию пол. признаков определимся с основными моделями задачи. Будем использовать логистическую регрессию и случайный лес. Найдем для каждого класса лучшие параметры модели."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 7.1 Лес"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "RANDOM_STATE = 0\n",
    "forrest_param = {'n_estimators' : range(50, 160, 10), 'max_depth' : range(1,5), 'min_samples_leaf': range(1,10)}\n",
    "\n",
    "clf = RandomForestClassifier(random_state = RANDOM_STATE, n_estimators = 50, max_depth = 10, min_samples_leaf = 5)\n",
    "tree_grid = GridSearchCV(clf, forrest_param, cv=30, n_jobs=-1, scoring = 'roc_auc')\n",
    "tree_grid.fit(df.drop(['target'], axis=1), df['target'])\n",
    "print(tree_grid.best_params_)\n",
    "print(tree_grid.best_score_)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 7.2 Логистическая регрессия"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "log_param = {'penalty' : ['l1', 'l2'], 'C' : np.linspace(0.0001, 1.0, 1000)}\n",
    "clf_log = LogisticRegression(random_state = RANDOM_STATE, class_weight = 'balanced');\n",
    "log_grid = GridSearchCV(clf_log, log_param, cv=30, n_jobs=-1, scoring = 'roc_auc')\n",
    "log_grid.fit(df.drop(['target'], axis=1), df['target'])\n",
    "print(log_grid.best_params_)\n",
    "print(log_grid.best_score_)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "Обратим внимание на то, что логистическая регрессия показала лучший результат на кросс-валидации, получим результат предсказания моделей для отложенной выборки. Будем строить результат для её урезанной части, т.к. для остальной части результат известен и он завысит качество модели. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "clf = RandomForestClassifier(n_estimators = 50, max_depth = 2, min_samples_leaf = 7, class_weight = 'balanced', random_state = 0)\n",
    "clf.fit(df.drop(['target'], axis=1), df['target'])\n",
    "pred = clf.predict_proba(DSinB.drop(['target'], axis=1))\n",
    "print('random forrest roc_auc score = ', roc_auc_score(DSinB['target'], pred[:,1]))\n",
    "\n",
    "LogisticRegression(C = 0.039135135135135134, penalty = 'l2', random_state = 0, class_weight = 'balanced');\n",
    "clf.fit(df.drop(['target'], axis=1), df['target'])\n",
    "pred = clf.predict_proba(DSinB.drop(['target'], axis=1))\n",
    "print('Logist regression roc_auc score = ', roc_auc_score(DSinB['target'], pred[:,1]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 7.3 Построение биномильных признаков"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Построим для каждой из модели пол. признаки. Строить будем следующим образом:\n",
    "\n",
    "1) найдем все сочетания произведения признаков;\n",
    "\n",
    "2) Каждое произведение добавим к признакам и найдем на сколько повышается качество модели на кросс-валидации;\n",
    "\n",
    "3) Отранжируем список и возьмем произведение с максимальным результатом;\n",
    "\n",
    "Повторять этот алгоритм будем пока произведения признаков будут улучшать качество модели. \n",
    "\n",
    "\n",
    "Построим биномильные признаки для логистической регрессии."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def Cross_val_score_in_this(clf, X, y, kf):\n",
    "    res = []\n",
    "    for train_index, test_index in kf.split(X):\n",
    "        X_train, X_test = X[train_index], X[test_index]\n",
    "        y_train, y_test = y[train_index], y[test_index]\n",
    "        clf.fit(X_train, y_train);\n",
    "        y_pred = clf.predict_proba(X_test);\n",
    "        res += [roc_auc_score(y_test, y_pred[:,1])];\n",
    "    res = np.array(res);\n",
    "    return res.mean();\n",
    "\n",
    "def definite_new_columns(clf, df, min_value, cc):\n",
    "    Columns = [i for i in df.drop('target', axis = 1).columns];\n",
    "    Bin_columns = {};\n",
    "    for i in df.drop('target', axis = 1).columns:\n",
    "        Bin_columns[i] = [j for j in Columns];\n",
    "        del Columns[0];\n",
    "          \n",
    "    max_value = 0;\n",
    "    max_name = 0;\n",
    "    i_max = 0;\n",
    "    j_max = 0;\n",
    "    for i in Bin_columns.keys():\n",
    "        for j in Bin_columns[i]:\n",
    "            NC = np.array(df[i]);\n",
    "            NC_1 = np.array(df[j]);\n",
    "            df['New_col'] = np.array(df[i])*np.array(df[j])\n",
    "            X_train = np.array(df.drop(['target'], axis=1))\n",
    "            Y_train = np.array(df['target'])\n",
    "            p = Cross_val_score_in_this(clf, X_train, Y_train, kf) - min_value;\n",
    "            if p > 0.0 and p > max_value and i+' x '+j not in cc:\n",
    "                max_value = p;\n",
    "                max_name = i+' x '+j;\n",
    "                i_max = i;\n",
    "                j_max = j;\n",
    "            del df['New_col']\n",
    "    return [i_max, j_max, max_name, max_value]\n",
    "    \n",
    "RANDOM_STATE = 0\n",
    "stop_columns = []\n",
    "kf = KFold(n_splits = 21, shuffle = True, random_state = 0)\n",
    "clf = LogisticRegression(random_state = RANDOM_STATE, class_weight = 'balanced', C = 0.039135135135135134, penalty = 'l2')\n",
    "X_train = np.array(df.drop(['target'], axis=1))\n",
    "Y_train = np.array(df['target'])\n",
    "nc = Cross_val_score_in_this(clf, X_train, Y_train, kf)\n",
    "while 1 > 0:\n",
    "    r = definite_new_columns(clf, df, nc, stop_columns);\n",
    "    if r[0] == 0:\n",
    "        break;\n",
    "    stop_columns += [r[2]]\n",
    "    if r[3] > 0:\n",
    "        df[r[2]] = np.array(df[r[0]])*np.array(df[r[1]])\n",
    "        stop_columns = [i for i in df.columns]\n",
    "        X_train = np.array(df.drop(['target'], axis=1))\n",
    "        Y_train = np.array(df['target'])\n",
    "        nc = Cross_val_score_in_this(clf, X_train, Y_train, kf)\n",
    "        print(str(r[2])+'   '+str(nc))\n",
    "print('finish')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Качество модели удалось немного повысить, теперь вернемся к исходным признакам и построим биномильные признаки для случайного леса. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "vanila = ['target', 'Attr1', 'Attr2', 'Attr3', 'Attr4', 'Attr5', 'Attr6', 'Attr7',\n",
    "       'Attr8', 'Attr9', 'Attr10', 'Attr11', 'Attr12', 'Attr13', 'Attr14',\n",
    "       'Attr15', 'Attr16']\n",
    "for i in df.columns:\n",
    "    if i not in vanila:\n",
    "        del df[i]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "RANDOM_STATE = 0\n",
    "stop_columns = []\n",
    "kf = KFold(n_splits = 21, shuffle = True, random_state = 0)\n",
    "clf = RandomForestClassifier(random_state = RANDOM_STATE, n_estimators = 50, max_depth = 2, min_samples_leaf = 7)\n",
    "X_train = np.array(df.drop(['target'], axis=1))\n",
    "Y_train = np.array(df['target'])\n",
    "nc = Cross_val_score_in_this(clf, X_train, Y_train, kf)\n",
    "while 1 > 0:\n",
    "    r = definite_new_columns(clf, df, nc, stop_columns);\n",
    "    if r[0] == 0:\n",
    "        break;\n",
    "    stop_columns += [r[2]]\n",
    "    if r[3] > 0:\n",
    "        df[r[2]] = np.array(df[r[0]])*np.array(df[r[1]])\n",
    "        stop_columns = [i for i in df.columns]\n",
    "        X_train = np.array(df.drop(['target'], axis=1))\n",
    "        Y_train = np.array(df['target'])\n",
    "        nc = Cross_val_score_in_this(clf, X_train, Y_train, kf)\n",
    "        print(str(r[2])+'   '+str(nc))\n",
    "print('finish')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Качество модели повысилось незначительно, это можно объяснить самой структурой модели. Случайный лес и так может строить нелинейные поверхности разделения, поэтому добавления нелинейных признаков для него \"погоды не сделают\"."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "Посмотрим насколько повысился результат на отложенной выборке. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df['Attr8 x Attr13'] = df['Attr8']*df['Attr13']\n",
    "df['Attr11 x Attr15'] = df['Attr11']*df['Attr15']\n",
    "df['Attr10 x Attr10'] = df['Attr10']*df['Attr10']\n",
    "df['Attr11 x Attr15 x Attr11 x Attr15'] = df['Attr11 x Attr15'] * df['Attr11 x Attr15']\n",
    "df['Attr9 x Attr16'] = df['Attr10']*df['Attr10']\n",
    "df['Attr2 x Attr11 x Attr15 x Attr11 x Attr15'] = df['Attr2']*df['Attr11 x Attr15 x Attr11 x Attr15']\n",
    "df['Attr10 x Attr13'] = df['Attr10']*df['Attr13']\n",
    "df['Attr7 x Attr10 x Attr13'] = df['Attr7']*df['Attr10 x Attr13']\n",
    "df['Attr10 x Attr14'] = df['Attr10']*df['Attr14']\n",
    "df['Attr6 x Attr7'] = df['Attr6']*df['Attr7']\n",
    "df['Attr14 x Attr11 x Attr15'] = df['Attr14']*df['Attr11 x Attr15']\n",
    "\n",
    "\n",
    "DSinB['Attr8 x Attr13'] = DSinB['Attr8']*DSinB['Attr13']\n",
    "DSinB['Attr11 x Attr15'] = DSinB['Attr11']*DSinB['Attr15']\n",
    "DSinB['Attr10 x Attr10'] = DSinB['Attr10']*DSinB['Attr10']\n",
    "DSinB['Attr11 x Attr15 x Attr11 x Attr15'] = DSinB['Attr11 x Attr15'] * DSinB['Attr11 x Attr15']\n",
    "DSinB['Attr9 x Attr16'] = DSinB['Attr10']*DSinB['Attr10']\n",
    "DSinB['Attr2 x Attr11 x Attr15 x Attr11 x Attr15'] = DSinB['Attr2']*DSinB['Attr11 x Attr15 x Attr11 x Attr15']\n",
    "DSinB['Attr10 x Attr13'] = DSinB['Attr10']*DSinB['Attr13']\n",
    "DSinB['Attr7 x Attr10 x Attr13'] = DSinB['Attr7']*DSinB['Attr10 x Attr13']\n",
    "DSinB['Attr10 x Attr14'] = DSinB['Attr10']*DSinB['Attr14']\n",
    "DSinB['Attr6 x Attr7'] = DSinB['Attr6']*DSinB['Attr7']\n",
    "DSinB['Attr14 x Attr11 x Attr15'] = DSinB['Attr14']*DSinB['Attr11 x Attr15']\n",
    "\n",
    "LogisticRegression(C = 0.039135135135135134, penalty = 'l2', random_state = 0, class_weight = 'balanced');\n",
    "clf.fit(df.drop(['target'], axis=1), df['target'])\n",
    "pred = clf.predict_proba(DSinB.drop(['target'], axis=1))\n",
    "print('Logist regression roc_auc score = ', roc_auc_score(DSinB['target'], pred[:,1]))\n",
    "\n",
    "vanila = ['target', 'Attr1', 'Attr2', 'Attr3', 'Attr4', 'Attr5', 'Attr6', 'Attr7',\n",
    "       'Attr8', 'Attr9', 'Attr10', 'Attr11', 'Attr12', 'Attr13', 'Attr14',\n",
    "       'Attr15', 'Attr16']\n",
    "for i in df.columns:\n",
    "    if i not in vanila:\n",
    "        del df[i]\n",
    "        del DSinB[i]\n",
    "        \n",
    "df['Attr1 x Attr1'] = df['Attr1']*df['Attr1']\n",
    "df['Attr13 x Attr14'] = df['Attr13']*df['Attr14']\n",
    "DSinB['Attr1 x Attr1'] = DSinB['Attr1']*DSinB['Attr1']\n",
    "DSinB['Attr13 x Attr14'] = DSinB['Attr13']*DSinB['Attr14']\n",
    "\n",
    "\n",
    "clf = RandomForestClassifier(n_estimators = 50, max_depth = 2, min_samples_leaf = 7, class_weight = 'balanced', random_state = 0)\n",
    "clf.fit(df.drop(['target'], axis=1), df['target'])\n",
    "pred = clf.predict_proba(DSinB.drop(['target'], axis=1))\n",
    "print('random forrest roc_auc score = ', roc_auc_score(DSinB['target'], pred[:,1]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Результат на отложенной выборки упал, следовательно новые признаки \"подстроены\" под обучающие данные. Для леса мы просто не будем их использовать, для логистической регрессии попробуем удалить лишние признаки для повышения качества. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "vanila = ['target', 'Attr1', 'Attr2', 'Attr3', 'Attr4', 'Attr5', 'Attr6', 'Attr7',\n",
    "       'Attr8', 'Attr9', 'Attr10', 'Attr11', 'Attr12', 'Attr13', 'Attr14',\n",
    "       'Attr15', 'Attr16']\n",
    "for i in df.columns:\n",
    "    if i not in vanila:\n",
    "        del df[i]\n",
    "        \n",
    "for i in DSinB.columns:\n",
    "    if i not in vanila:\n",
    "        del DSinB[i]        \n",
    "\n",
    "df['Attr8 x Attr13'] = df['Attr8']*df['Attr13']\n",
    "df['Attr11 x Attr15'] = df['Attr11']*df['Attr15']\n",
    "df['Attr10 x Attr10'] = df['Attr10']*df['Attr10']\n",
    "df['Attr11 x Attr15 x Attr11 x Attr15'] = df['Attr11 x Attr15'] * df['Attr11 x Attr15']\n",
    "df['Attr9 x Attr16'] = df['Attr10']*df['Attr10']\n",
    "df['Attr2 x Attr11 x Attr15 x Attr11 x Attr15'] = df['Attr2']*df['Attr11 x Attr15 x Attr11 x Attr15']\n",
    "df['Attr10 x Attr13'] = df['Attr10']*df['Attr13']\n",
    "df['Attr7 x Attr10 x Attr13'] = df['Attr7']*df['Attr10 x Attr13']\n",
    "df['Attr10 x Attr14'] = df['Attr10']*df['Attr14']\n",
    "df['Attr6 x Attr7'] = df['Attr6']*df['Attr7']\n",
    "df['Attr14 x Attr11 x Attr15'] = df['Attr14']*df['Attr11 x Attr15']\n",
    "\n",
    "\n",
    "DSinB['Attr8 x Attr13'] = DSinB['Attr8']*DSinB['Attr13']\n",
    "DSinB['Attr11 x Attr15'] = DSinB['Attr11']*DSinB['Attr15']\n",
    "DSinB['Attr10 x Attr10'] = DSinB['Attr10']*DSinB['Attr10']\n",
    "DSinB['Attr11 x Attr15 x Attr11 x Attr15'] = DSinB['Attr11 x Attr15'] * DSinB['Attr11 x Attr15']\n",
    "DSinB['Attr9 x Attr16'] = DSinB['Attr10']*DSinB['Attr10']\n",
    "DSinB['Attr2 x Attr11 x Attr15 x Attr11 x Attr15'] = DSinB['Attr2']*DSinB['Attr11 x Attr15 x Attr11 x Attr15']\n",
    "DSinB['Attr10 x Attr13'] = DSinB['Attr10']*DSinB['Attr13']\n",
    "DSinB['Attr7 x Attr10 x Attr13'] = DSinB['Attr7']*DSinB['Attr10 x Attr13']\n",
    "DSinB['Attr10 x Attr14'] = DSinB['Attr10']*DSinB['Attr14']\n",
    "DSinB['Attr6 x Attr7'] = DSinB['Attr6']*DSinB['Attr7']\n",
    "DSinB['Attr14 x Attr11 x Attr15'] = DSinB['Attr14']*DSinB['Attr11 x Attr15']\n",
    "\n",
    "while 1 > 0:\n",
    "    poly_columns = []\n",
    "    for i in df.columns:\n",
    "        if i not in vanila:\n",
    "            poly_columns += [i]\n",
    "    clf.fit(df.drop(['target'], axis=1), df['target'])\n",
    "    pred = clf.predict_proba(DSinB.drop(['target'], axis=1))\n",
    "    nc = roc_auc_score(DSinB['target'], pred[:,1])\n",
    "    ncmax = 0;\n",
    "    imax = ''\n",
    "    for i in poly_columns:\n",
    "        clf.fit(df.drop(['target', i], axis=1), df['target'])\n",
    "        pred = clf.predict_proba(DSinB.drop(['target', i], axis=1))\n",
    "        nc1 = roc_auc_score(DSinB['target'], pred[:,1])\n",
    "        if nc1 > ncmax:\n",
    "            ncmax = nc1;\n",
    "            imax = i;\n",
    "    if ncmax > nc:\n",
    "        print(imax, ncmax)\n",
    "        del df[imax]\n",
    "        del DSinB[imax]\n",
    "    else:\n",
    "        break"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Удалив часть ненужных признаков, мы повысили исходный результат."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 8.Финальный результат и выводы"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Добавим к последнему полученному результату строки отделенные построенной нами поверхностью и получим финальный результат."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "clf.fit(df.drop(['target'], axis=1), df['target'])\n",
    "pred = clf.predict_proba(DSinB.drop(['target'], axis=1))\n",
    "true_result = [i for i in DSinB['target']]\n",
    "for i in range(len(DSnotinB)):\n",
    "    true_result += [1];\n",
    "    true_pred += [1]\n",
    "true_result = np.array(true_result)\n",
    "true_pred = np.array(true_pred)\n",
    "nc = roc_auc_score(true_result, true_pred)\n",
    "print(nc)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Результат сильно превосходит baseline, следовательно анализ можно считать успешным. Укажем недостатки проведенного нами анализа:\n",
    "\n",
    "1) Данные на последнем этапе еще можно дальше преобразовывать для получения все более точных прогнозов.\n",
    "\n",
    "2) Способ, которым мы обрезали данные, не совсем корректен. Он сильно зависит от самих данных и в реальных бизнес задачах для грамотной расстановки границ нужно привлекать эксперта в данной области. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
